/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package Principal;

import Data.Enemigo.Ejecucion;
import Data.Enemigo.Enemigo;
import Data.Enemigo.ManejoEnemigo;
import Data.Enemigo.NivelPotencia;
import Data.Enemigo.NodoArma;
import Data.Enemigo.NodoEstrategia;
import Data.Jugador;
import Data.Nivel;
import Data.NodoCasilla;
import Data.NodoEspacio;
import Data.NodoEspecial;
import java.awt.Color;
import java.awt.Font;
import java.awt.FontMetrics;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Rectangle;
import java.awt.Toolkit;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import java.util.ArrayList;
import java.util.Map;
import javax.swing.ImageIcon;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.Timer;

/**
 *
 * @author REI
 */
public class Tablero extends JPanel implements ActionListener{
    
    
    private Jugador jugador;
    private Timer tiempo;
    public Casilla[][] casillas;
    private Nivel nivel;
    private boolean jugando;
    private int ancho = 600;
    private final int LARGO = 160;
    private int cont;    
    private boolean invencible;
    private int inv;
    private ArrayList<Nivel> niveles;
    private ArrayList<ManejoEnemigo> manejoenemigos;
    private ArrayList<Enemigo> enemigos;
    private int LEVEL;
    private int TRANS = 50;
    public int HUD =0;
    private String mensajefinal;
    private boolean cambio;
    boolean EnemigoActivo;
    private final ImageIcon life = new ImageIcon(this.getClass().getResource("/img/heart1.gif"));
    private final ImageIcon magic = new ImageIcon(this.getClass().getResource("/img/magicfairy.gif"));
    public Sonidos sonido = new Sonidos();
    public int time;
    private Estadisticas estadistica;
       
    public Tablero(Jugador jugador, ArrayList<Nivel> niveles, ArrayList<ManejoEnemigo> enemys) {
        
        addKeyListener(new TAdapter());
        setBackground(Color.BLACK);
        
        setFocusable(true);
        setDoubleBuffered(true);
        
        
        this.niveles = niveles;
        this.jugador = jugador;
        this.manejoenemigos = enemys;
        this.enemigos = new ArrayList<Enemigo>();
        this.LEVEL =0;
        crearNivel();
        jugando = true;
        this.cont=0;
        this.time=0;
        this.inv =0;
        this.EnemigoActivo = false;
        tiempo = new Timer(100, this);
        tiempo.start();
    }
    
    
    @Override
    public void paint(Graphics g) {
        super.paint(g);

        Graphics2D g2d = (Graphics2D)g;
        if (jugando) 
        {
            

            dibujarNivel(g2d);
            
            dibujarInfo(g2d, g);
            dibujarAtacar(g);
            dibujarHud(g2d, g);
            
            dibujarDisparoEnemigos(g2d);

            for (Enemigo enemy : enemigos) {

                g2d.drawImage(enemy.getImgn(), enemy.getX(), enemy.getY(), this);

            }

            ArrayList<Ataque> ms = jugador.getHechizos();

            for (int i = 0; i < ms.size(); i++) {
                Ataque m = (Ataque)ms.get(i);
                if(m.isVisible())
                {
                g2d.drawImage(m.getImagen(), m.getX(), m.getY(), this);
                }
            }
            
            dibujarAtaques(g2d);
            
            if (jugador.isVisible())
                g2d.drawImage(jugador.getImagen(), jugador.getX(), jugador.getY(),
                              this);

        }
        else
        {
            if(cambio)
            {
                cambiarNivel();
                dibujarFinal(g2d, g, mensajefinal);
            }
            else{
                dibujarFinal(g2d, g, mensajefinal);
            }
            
        }

        Toolkit.getDefaultToolkit().sync();
        g.dispose();
    }
    
    
    private void dibujarInfo(Graphics2D g2d, Graphics g)
    {
            g2d.setColor(Color.BLACK);
            g2d.fillRect(0, 0,ancho,LARGO);
            
            Font fuente = new Font("Emulogic", Font.BOLD, 8);
            FontMetrics metr = this.getFontMetrics(fuente);
            
            //*******************Nombre***************************
            String msg0 = jugador.getNombre();
            g.setColor(Color.white);
            g.setFont(fuente);
            g.drawString(msg0, 0, 20);
            
            
            if(invencible)
            {
                if(cont%2==0)
                {
                    g2d.setColor(Color.YELLOW);
                }
                else
                {
                    g2d.setColor(Color.GREEN);
                }
                
            }
            else
            {
                g2d.setColor(Color.GREEN);
            }            
            
            //********************Vida*******************************
            
            String msg = "vida ";            
            g2d.fillRect(metr.stringWidth(msg)+11,30, jugador.getVida(),10);            
            g.setColor(Color.white);
            g.setFont(fuente);
            g.drawString(msg,0, 40);
            g2d.setColor(Color.white);
            g2d.drawRect(metr.stringWidth(msg)+11,30, jugador.getVida(),10);
            
            //********************Ataque*****************************
            g2d.setColor(Color.CYAN);
            String msg1 = "magia ";
            g2d.fillRect(metr.stringWidth(msg1),50, jugador.getMagia(),10);
            g2d.setColor(Color.white);
            g2d.drawRect(metr.stringWidth(msg1),50, jugador.getMagia(),10);
            
            g.setColor(Color.white);
            g.setFont(fuente);
            g.drawString(msg1,0, 60);
            
            //*******************Nivel*******************************
            String msg2 = "Nivel - "+String.valueOf(LEVEL+1);
            g.setColor(Color.white);
            g.setFont(fuente);
            int left = ancho-metr.stringWidth(msg2)-40;
            g.drawString(msg2, left, 40);
            
            //*******************Tiempo******************************
            String msg3 = "Tiempo: "+String.valueOf(cont/10);
            g.setColor(Color.white);
            g.setFont(fuente);
            g.drawString(msg3, left, 60);
            
                        
            
    }
    
    private void dibujarAtacar(Graphics g)
    {
        Font fuente = new Font("Emulogic", Font.BOLD, 8);
        FontMetrics metr = this.getFontMetrics(fuente);
        g.setColor(Color.yellow);
        g.setFont(fuente);
        String display ="Atacar!!!";
        for(Enemigo en: enemigos)
        {
            if(en.getArma()!=null)
            {
                if(en.getArma().isMinimo())
                {
                    if(cont%2==0)
                    {
                        g.drawString(display, ancho/2-metr.stringWidth(display)/2,60);
                    }
                }
            }
            
                
        }
    }

    private void dibujarHud(Graphics2D g2d, Graphics g)
    {
        Font fuente = new Font("Emulogic", Font.BOLD, 8);
        FontMetrics metr = this.getFontMetrics(fuente);


        switch(HUD)
        {
            case 0: //enemigo  municiones
            {

                g.setColor(Color.red);
                g.setFont(fuente);
                String display = "Enemigos";
                g2d.drawLine(0, 80, 300-metr.stringWidth(display)/2, 80);
                g.drawString(display, 300-metr.stringWidth(display)/2,84);
                g2d.drawLine(300+metr.stringWidth(display)/2, 80,600, 80);

                int x =0;
                String nombre;
                String municiones;
                String punteo;

                for(Enemigo en: enemigos)
                {
                    if(x < 500)
                    {
                    nombre = "Nombre: "+en.getNombre();
                    g.drawString(nombre, x, 100);

                    if(en.getArma()!=null)
                    {
                        municiones = "Municiones: "+en.getArma().getMuniciones();
                        g.drawString(municiones, x, 120);
                    }
                    else
                    {
                        municiones = "Municiones: 0";
                        g.drawString(municiones, x, 120);
                    }

                    if(en.getEstrategia()!=null)
                    {
                        punteo = "Punteo: "+en.getEstrategia().getPunteo();
                        g.drawString(punteo, x, 140);
                    }
                    else
                    {
                        punteo = "Punteo: 0";
                        g.drawString(punteo, x, 140);
                    }


                        x=x+metr.stringWidth(nombre)+10;
                    }
                }
                break;
            }
            case 1: // punteo
            {
                g.setColor(Color.blue);
                g.setFont(fuente);
                String display = "Estrategias";
                g2d.drawLine(0, 80, 300-metr.stringWidth(display)/2, 80);
                g.drawString(display, 300-metr.stringWidth(display)/2,84);
                g2d.drawLine(300+metr.stringWidth(display)/2, 80,600, 80);
                

                int x =0;
                String nombre;                
                String punteo;
                NodoEstrategia estrategia;

                for(ManejoEnemigo en: manejoenemigos)
                {

                    for (Map.Entry e : en.getEstrategias().entrySet()) {

                        if(x < 500)
                        {

                        estrategia = (NodoEstrategia)e.getValue();
                        nombre = "Nom: "+ estrategia.getNombre();
                        g.drawString(nombre, x, 100);
                        punteo = "Pto: "+ String.valueOf(estrategia.getPunteo());
                        g.drawString(punteo, x, 120);
                        x=x+metr.stringWidth(nombre)+10;

                        }
                    }
                    
                }
                break;
            }
            case 2: //armas
            {
                g.setColor(Color.green);
                g.setFont(fuente);
                String display = "Armas";
                g2d.drawLine(0, 80, 300-metr.stringWidth(display)/2, 80);
                g.drawString(display, 300-metr.stringWidth(display)/2,84);
                g2d.drawLine(300+metr.stringWidth(display)/2, 80,600, 80);

                int x =0;
                String nombre;
                String punteo;
                NodoArma arma;

                for(ManejoEnemigo en: manejoenemigos)
                {

                    for (Map.Entry e : en.getArmas().entrySet()) {

                        if(x < 500)
                        {

                        arma = (NodoArma)e.getValue();
                        nombre = "Nom: "+ arma.getNombre();
                        g.drawString(nombre, x, 100);
                        punteo = "Mun: "+ String.valueOf(arma.getMuniciones());
                        g.drawString(punteo, x, 120);
                        x=x+metr.stringWidth(nombre)+10;

                        }
                    }

                }
                break;
            }
        }
        


    }
    
    private void dibujarFinal(Graphics2D g2d, Graphics g, String msg)
    {
        int w = this.getWidth();
        int h = this.getHeight();
        
        g2d.setColor(Color.BLACK);
        g2d.drawRect(0, 0, w, h);
        
        Font fuente = new Font("Emulogic", Font.BOLD, 10);
        FontMetrics metr = this.getFontMetrics(fuente);
        
        if(cont % 2 ==0)
        {
            g.setColor(Color.blue);
        }
        else
        {
            g.setColor(Color.red);
        }
        
        g.setFont(fuente);
        g.drawString(msg,(w-metr.stringWidth(msg))/2, h/2);
        
    }
    
    private void dibujarDisparoEnemigos(Graphics2D g2d)
    {
        
        ArrayList<Ataque> ataques;
        Ataque ataque;
        for (Enemigo enemigo: enemigos) {
            
            ataques = enemigo.getDisparos();
            
            for(int i=0; i < ataques.size(); i++)
            {
                ataque = ataques.get(i);
                
                if(ataque.isVisible())
                {
                    g2d.drawImage(ataque.getImagen(), ataque.getX(), ataque.getY(), this);
                }
                else
                {
                    ataques.remove(i);
                }
                
            }
            
        }
                }
                
    private void dibujarAtaques(Graphics2D g2d)
    {
        ArrayList<Golpe> ataques = jugador.getAtaques();
        
        for (Golpe golpe : ataques) {
            
            if(golpe.isVisible())
            {
                g2d.drawImage(golpe.getImagen(),golpe.getX(),golpe.getY(), this);
            }
        }
    }
    private void crearNivel()
    {
        
        if(LEVEL < niveles.size())
        {
            nivel = niveles.get(LEVEL);
            
            int w = nivel.getAncho();
            int h = nivel.getAlto();
            Casilla casillaaux;
            int x =0;
            int y =0;
            int xi = calcularX(w);
            int altoaux =0;
            String rutaimagen=null;
            ArrayList<Casilla> lista;
            lista = new ArrayList<Casilla>();
            NodoCasilla matriz[][] = nivel.getMatriz();

            casillas = new Casilla[w][h]; //iniciamos las casillas con el tamaño indicado        

            y = y + LARGO;
            
            if(!enemigos.isEmpty())
            {
                enemigos.clear();
            }

            for(int f =0;  f<w; f++)
            {
                x = xi;
                for(int c =0; c<h; c++)
                {
                  rutaimagen = buscarImagenCasilla(matriz[f][c].getTipo());

                  if(rutaimagen!=null)
                  {
                      casillaaux = new Casilla(rutaimagen);
                      casillaaux.setLimite(x, y);
                      casillaaux.setCoordenadas(c, f);
                      casillas[f][c]  = casillaaux;
                      if(buscarEspacio(matriz[f][c])!=null)
                      {
                          casillas[f][c].setEspacio(buscarEspacio(matriz[f][c]));

                          if(casillas[f][c].getEspacio().isInicio())
                          {

                                jugador.setCol(c);
                                jugador.setFil(f);

                          }
                          if(casillas[f][c].getEspacio().isEnemigo())
                          {
                              lista.add(casillas[f][c]);
                          }



                      }



                      x = x + casillaaux.getAncho();
                      altoaux = casillaaux.getAlto();
                  }


                }

                y = y + altoaux;
            }


            if(60*w > ancho)
            {
                ancho = 60*w;
            }

            
            jugador.setLimites(xi, LARGO, xi+(60*w)-5,LARGO+(60*h)-5 );
            setSize(ancho, y);
            jugador.setCasillas(casillas);
            crearEnemigos(nivel, lista, x, y, xi);
            
        }
        
        

       
    }

    private int calcularX(int w)
    {
        int x =0;
        int level = 60 * w;

        if(level < ancho)
        {
            x = (ancho/2)-(level/2);
        }

        return x;
    }
    
    private void crearEnemigos(Nivel level, ArrayList<Casilla> lista, int limx, int limy, int xi)
    {
        int enemys;
        int indice;
        enemys = level.getCasilla_enemigos();
        ArrayList<Enemigo> lstenemigos;
        Enemigo enemigo;
        
        for(int m = 0; m < manejoenemigos.size(); m++) //recorremos la lista de archivos de enemigos
        {
            manejoenemigos.get(m).setCasillas(casillas);
            lstenemigos = manejoenemigos.get(m).getMisenemigos(); //recorremos la lista enemigos en el archivo de enemigo
            indice = 0;
            indice = indice + m;
            for(int e = 0; e < lstenemigos.size(); e++)
            {
                
                
                if(indice < enemys)
                {
                    enemigo = (Enemigo)lstenemigos.get(e).clone();
                    enemigo.setLimitex1(xi);
                    enemigo.setLimitey1(LARGO);
                    enemigo.setLimitex2(limx);
                    enemigo.setLimitey2(limy);
                    enemigo.setPosicionInicial(lista.get(indice));
                    enemigo.setArchivo(manejoenemigos.get(m).getId());
                    enemigos.add(enemigo); 
                    
                }
                
                if(indice < enemys && e == lstenemigos.size()-1)
                {
                    e = -1;
                }
                
                
                if(indice >= enemys)
                {
                    break;
                }
                
                indice = indice + manejoenemigos.size();
                
            }
            
        }
        
        //agregamos los enemigos que creamos en los archivos de enemigos
        for (ManejoEnemigo enemigo1 : manejoenemigos) {            
            
            enemigo1.setLstenemigos(enemigos);
        }
        
        EnemigoActivo = false;
        
        
    }
    
    private void dibujarNivel(Graphics2D g2d)
    {
        int w = nivel.getAncho();
        int h = nivel.getAlto();
        Casilla casillaaux;
        int x =0;
        int y =0;
        int xi = calcularX(w);
        int altoaux =0;
        ArrayList<NodoEspecial> especial; 
              

        y = y + LARGO;

        for(int f =0;  f<w; f++)
        {
            x = xi;
            for(int c =0; c<h; c++)
            {
              
                  casillaaux = casillas[f][c];                  
                  g2d.drawImage(casillaaux.getImagen(), x, y, this);
                  especial = casillaaux.getEspacio().getEspecial();
                  if(especial!=null)
                  {
                      for (NodoEspecial nodoEspecial : especial) {

                            if(nodoEspecial.getNombre().compareTo("cura")==0)
                            {
                                if(nodoEspecial.getValor()>0)
                                {
                                    g2d.drawImage(life.getImage(), x +casillaaux.getAncho()/2-9, y +casillaaux.getAlto()/2-6, this);
                                }
                            }
                            else if(nodoEspecial.getNombre().compareTo("magia")==0)
                            {
                                if(nodoEspecial.getValor()>0)
                                {
                                    g2d.drawImage(magic.getImage(),  x +casillaaux.getAncho()/2-10, y +casillaaux.getAlto()/2-8, this);
                                }
                            }
                      }
                  }
                  
                  x = x + casillaaux.getAncho();
                  altoaux = casillaaux.getAlto();
              


            }

            

            y = y + altoaux;
        }

        
        
        

       
    }
    
    public NodoEspacio buscarEspacio(NodoCasilla casilla)
    {        
        NodoEspacio espacio = nivel.buscarEspacio(casilla.getTipo());
        return espacio;
        
    }
    
    private String buscarImagenCasilla(String nombre)
    {
        NodoEspacio espacioaux;
        String rutaImagen=null;

        espacioaux =nivel.buscarEspacio(nombre);

        if(espacioaux!=null)
        {
            rutaImagen = espacioaux.getImagen();
            return rutaImagen;
        }
        else
        {
            return rutaImagen;
        }

    }
    
    
    
    public void colisionDisparoParedes(ArrayList<Ataque> disparos)
    {
        int w = nivel.getAncho();
        int h = nivel.getAlto();
        Casilla aux;
        Rectangle u1, u2;
        
        for(int f=0;f<w;f++ )
        {
            for (int c= 0; c < h; c++) {                
                
                aux = casillas[f][c];
                u2 = aux.getLimite();
                   
                
                
                for (Ataque magia: disparos) {
                    
                    u1 = magia.getUbicacion();
                    
                    if(u1.intersects(u2))
                    {
                        if(!casillas[f][c].getEspacio().isPasable())
                        {
                            if(magia.getEstrategia()!=null)
                            {
                                magia.getEstrategia().actualizarpunteo(-2);
                            }
                            magia.setVisible(false);
                            System.out.println("desaparece");
                            
                        }
                        
                    }
                    else
                    {
                          System.out.println("no paso nada en la colision");
                    }
                }
                
                
            }
        }
    }
    
    private void colisionEnemigos() //metodo que revisa si se chocaron los enemigos con el jugador
    {
        Rectangle j1, e1, e2;
        j1 = jugador.getUbicacion();
        for(int i=0; i < enemigos.size();i++)
        {
            e1 = enemigos.get(i).getUbicacion();
            
            if(j1.intersects(e1))
            {
                if(cont % 6==0)
                {
                    jugador.restarVida(enemigos.get(i).getPotencia().getNivel());
                    if(enemigos.get(i).getEstrategia()!=null)
                    {
                        enemigos.get(i).getEstrategia().actualizarpunteo(10);
                    }

                    verificarVidaJugador();
                }
                
                
                
                
            }
            else
            {
                for (Enemigo e3: enemigos) {
                    
                    e2 = e3.getUbicacion();
                    
                    if(e3!=enemigos.get(i))
                    {
                        if(e1.intersects(e2))
                        {
                            if(enemigos.get(i).getEstrategia()!=null)
                            {
                                enemigos.get(i).getEstrategia().actualizarpunteo(-1);
                            }

                            if(e3.getEstrategia()!=null)
                            {
                                e3.getEstrategia().actualizarpunteo(-1);
                            }
                        }
                        
                    }
                    
                    
                    
                }
            }
        }
    }
    private void verificarCasilla(int f, int c)
    {
        NodoCasilla ubicacion = nivel.obtenerCasilla(f, c);
        NodoEspacio espacio = nivel.buscarEspacio(ubicacion.getTipo());
        
        if(espacio.getEspecial()!=null)
        {
            ArrayList<NodoEspecial> especial= espacio.getEspecial();
            
            for (NodoEspecial nodoEspecial : especial) {
                
                if(nodoEspecial.getNombre().compareTo("dano")==0)
                {
                    
                    if(cont % 6==0)
                    {
                        jugador.restarVida(nodoEspecial.getValor());

                        verificarVidaJugador();
                    }
                   
                    
                }
                else if(nodoEspecial.getNombre().compareTo("cura")==0)
                {
                    jugador.recuperarVida(nodoEspecial.getValor());
                    if(nodoEspecial.getValor()>0)
                    {
                        sonido.efecto(Efectos.HEART);
                    }                    
                    nodoEspecial.setValor(0);
                    
                    
                }
                else if(nodoEspecial.getNombre().compareTo("magia")==0)
                {
                    jugador.recuperarMagia(nodoEspecial.getValor());
                    if(nodoEspecial.getValor()>0)
                    {
                        sonido.efecto(Efectos.FAIRY);
                    } 
                    nodoEspecial.setValor(0);
                }
                else if(nodoEspecial.getNombre().compareTo("invencible")==0)
                {                                         
                        invencible = true;
                        inv = cont + 100;
                        nodoEspecial.setNombre("vencible");                    
                    
                }
                
            }
           
        }
        
        if(espacio.isFin())
        {
            if(LEVEL == niveles.size()-1)
            {
                mensajefinal = "Felicidades "+jugador.getNombre()+" Ganaste!!!";
                jugando = false;
                cambio = false;
                time = cont /10;
                estadistica = new Estadisticas(this);
                estadistica.setExtendedState(JFrame.ICONIFIED);
                estadistica.setVisible(true);

                
            }
            else if(LEVEL < niveles.size())
            {
                LEVEL++;                
                TRANS = cont + 20;
                cambio = true;
                jugando = false;
                crearNivel();
                
                
            }
            
        }
        
    }
    
    private void hacerInvencible()
    {
                
        if(invencible)
        {
            if(cont < inv)
            {
                jugador.setInvencible(true);
            }
            else
            {
               
                jugador.setInvencible(false);
                invencible = false;
            }
        }
        
    }
    
    private void cambiarNivel()
    {
        
        if(LEVEL < niveles.size())
        {
                if(cont < TRANS)
                {

                    mensajefinal = "Nivel - "+String.valueOf(LEVEL+1);
                }
                else
                {

                    cambio = false;
                    jugando = true;
                    cont = cont -20;
                }
        }
        else if(LEVEL == niveles.size())
        {
            cambio = false;
        }
        else
        {
            cambio = false;
        }
        
        
    }
        
    @Override
    public void actionPerformed(ActionEvent e) {
        
        if(jugando)
        {
            ArrayList<Ataque> ms = jugador.getHechizos();

            for (int i = 0; i < ms.size(); i++) {
                Ataque m = (Ataque)ms.get(i);
                
                if(m.isVisible())
                {
                    m.mover();
                }
                else
                {
                    ms.remove(i);
                }
            }
            ataqueJugador();
            jugador.mover();

            verificarCasilla(jugador.getFil(),jugador.getCol());
            colisionDisparoParedes(jugador.getHechizos());        
                   
            hacerInvencible();



            if(EnemigoActivo==false)
            {
                Ejecucion ej;
                for(ManejoEnemigo en: manejoenemigos)
                {
                    ej = new Ejecucion(this, en);
                    ej.Iniciar();
            }
            }


            EnemigoActivo=true;
            pocaVida();
            disparoJugadorEnemigos();
            colisionEnemigos();
        }
        cont++;
        repaint();  
    }
    
    

    private void disparoJugadorEnemigos()//metodo que realiza el ataque del jugador al enemigo
    {
        ArrayList<Ataque> ataques;
        ArrayList<Golpe> golpes;
        Rectangle u1, u2;
       

        ataques = jugador.getHechizos();
        golpes = jugador.getAtaques();
        for (Enemigo enemigo: enemigos) {


            for(Ataque a: ataques)
            {
                u1 = enemigo.getUbicacion();
                u2 = a.getUbicacion();

                if(u1.intersects(u2))
                {
                    NodoArma es = enemigo.getArma();
                    if(es!=null)
                    {
                        es.restarMuniciones(1);
                        
                        
                    }
                    a.setVisible(false);
                    sonido.efecto(Efectos.HIT);
                }               


            }

            for(Golpe a: golpes)
            {
                u1 = enemigo.getUbicacion();
                u2 = a.getUbicacion();

                if(u1.intersects(u2))
                {
                    NodoArma es = enemigo.getArma();
                    if(es!=null)
                    {
                        es.restarMuniciones(1);
                        
                        
                    }
                    a.setVisible(false);
                    sonido.efecto(Efectos.HIT);
                }


            }


        }
    }
    
    private void ataqueJugador()//metodo para realizar el ataque normal del jugador
    {
        ArrayList<Golpe> ms = jugador.getAtaques();

            for (int i = 0; i < ms.size(); i++) {
                Golpe m = (Golpe)ms.get(i);
                
                if(m.isVisible())
                {
                    m.atacar();
                }
                else
                {
                    ms.remove(i);
                }
            }
    }
    
    public void verificarVidaJugador()
    {
        if(jugador.getVida()<=0)
        {
            mensajefinal = "Game over";
            time = cont / 10;
            jugando = false;
            estadistica = new Estadisticas(this);
            estadistica.setExtendedState(JFrame.ICONIFIED);
            estadistica.setVisible(true);

        }
    }
    
    private void pocaVida()
    {
        if(jugador.getVida()<=15)
        {
            if(cont%10==0)
            {
                sonido.efecto(Efectos.LIFE);
            }
            
        }
    }
    private class TAdapter extends KeyAdapter {

        @Override
        public void keyReleased(KeyEvent e) {
            if(jugando)
            {
               jugador.keyReleased(e); 
            }
            
        }

        @Override
        public void keyPressed(KeyEvent e) {
            if(jugando)
            {
                jugador.keyPressed(e);
            }
        }
    }

    public ArrayList<ManejoEnemigo> getManejoenemigos() {
        return manejoenemigos;
    }

    public void setManejoenemigos(ArrayList<ManejoEnemigo> manejoenemigos) {
        this.manejoenemigos = manejoenemigos;
    }

    

    public ArrayList<Enemigo> getEnemigos() {
        return enemigos;
    }

    public void setEnemigos(ArrayList<Enemigo> enemigos) {
        this.enemigos = enemigos;
    }

    public Nivel getNivel() {
        return nivel;
    }

    public Jugador getJugador() {
        return jugador;
    }

    public boolean isJugando() {
        return jugando;
    }

    public String getMensajefinal() {
        return mensajefinal;
    }

    public ArrayList<Nivel> getNiveles() {
        return niveles;
    }
    
    
    
}
